package com.h3c.ptability.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.eos.common.custom.BusinessException;
import com.h3c.ptability.cache.PtEnumCache;
import com.h3c.ptability.dto.ExcelFileDTO;
import com.h3c.ptability.entity.PtEnum;
import com.h3c.ptability.mapper.PtEnumMapper;
import com.h3c.ptability.service.CommService;
import com.h3c.ptability.service.IPtEnumService;
import com.h3c.ptability.dto.PtEnumDTO;
import com.h3c.ptability.service.IPtFileTemplateService;
import com.h3c.ptability.utils.AppBusinessException;
import com.h3c.ptability.utils.InitExampleOrderByUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import tk.mybatis.mapper.entity.Example;

import javax.annotation.Resource;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Copyright (C), 2020-2020, h3c
 * FileName: PtEnumServiceImpl
 *
 * @Author: l22886
 * @Date: 2022-03-14
 * Description: pt_enum serviceImpl
 * Version: 1.0
 */
@Slf4j
@Service
public class PtEnumServiceImpl extends ServiceImpl<PtEnumMapper, PtEnum> implements IPtEnumService {

    @Resource
    private PtEnumMapper ptEnumMapper;

    @Autowired
    private CommService commService;

    @Autowired
    IPtEnumService ptEnumService;

    /**
     * @title: selectFuzzyByDto
     * @description: 模糊查询操作
     * @params: [ dto ]
     * @return: java.util.List
     * @createTime: 2022-03-14
     * @version: 1.0
     * @author: l22886
     */
    @Override
    public List<PtEnumDTO> selectFuzzyByDto(PtEnumDTO dto) {
        //List<PtEnum> list = ptEnumMapper.selectByExample(initFuzzyExample(dto));
        List<PtEnum> list = ptEnumMapper.queryListByFuzzy(JSONObject.parseObject(JSONObject.toJSONString(dto), PtEnum.class));
        return JSONArray.parseArray(JSONArray.toJSONString(list), PtEnumDTO.class);
    }

    /**
     * @title: selectByDto
     * @description: 精确查询操作
     * @params: [ dto ]
     * @return: java.util.List
     * @createTime: 2022-03-14
     * @version: 1.0
     * @author: l22886
     */
    @Override
    public List<PtEnumDTO> selectByDto(PtEnumDTO dto) {
        //List<PtEnum> list = ptEnumMapper.selectByExample(initExample(dto));
        List<PtEnum> list = ptEnumMapper.queryList(JSONObject.parseObject(JSONObject.toJSONString(dto), PtEnum.class));
        return JSONArray.parseArray(JSONArray.toJSONString(list), PtEnumDTO.class);
    }

    /**
     * @title: insertDto
     * @description: 插入操作
     * @params: [ dto ]
     * @return: Integer
     * @createTime: 2022-03-14
     * @version: 1.0
     * @author: l22886
     */
    @Override
    public Integer insertDto(PtEnumDTO dto) {
        QueryWrapper<PtEnum> enumWrapper = Wrappers.query();
        enumWrapper.eq("app_id", dto.getAppId())
                .eq("enum_code", dto.getEnumCode())
                .eq("value", dto.getValue());
        PtEnum ptEnum = ptEnumMapper.selectOne(enumWrapper);
        if (ptEnum != null) {
            throw new AppBusinessException("已存在此枚举");
        }
        return ptEnumMapper.insertPtEnum(JSONObject.parseObject(JSON.toJSONString(dto), PtEnum.class));
    }


    /**
     * @title: updateDto
     * @description: 修改操作
     * @params: [ dto ]
     * @return: Integer
     * @createTime: 2022-03-14
     * @version: 1.0
     * @author: l22886
     */
    @Override
    public Integer updateDto(PtEnumDTO dto) {
        //if (null != dto && null != dto.getId() && !"".equals(dto.getId())) {
        return ptEnumMapper.updatePtEnum(JSONObject.parseObject(JSON.toJSONString(dto), PtEnum.class));
        //return ptEnumMapper.updateByPrimaryKey(JSONObject.parseObject(JSON.toJSONString(dto), PtEnum.class));
        //} else {
        //    return 0;
        //}
    }

    /**
     * @param
     * @title: deleteDto
     * @description: 删除操作
     * @params: [ dto ]
     * @return: Integer
     * @createTime: 2022-03-14
     * @version: 1.0
     * @author: l22886
     */
    @Override
    public Integer deleteDto(List<PtEnumDTO> dtoList) {
        dtoList.forEach(dto -> {
            Integer flag = ptEnumMapper.deletePtEnum(JSONObject.parseObject(JSON.toJSONString(dto), PtEnum.class));
            if (flag > 0) {
                PtEnum ptEnum = new PtEnum();
                BeanUtils.copyProperties(dto, ptEnum);
                PtEnumCache.deleteEnumDataInRedis(ptEnum);
            }
        });
        return 0;
    }

    @Override
    public List<PtEnum> queryEnumList(PtEnumDTO dto) {
        String appId = dto.getAppId();
        if (StringUtils.isEmpty(appId)) {
            throw new AppBusinessException("请传入appId");
        }
        QueryWrapper<PtEnum> enumWrapper = new QueryWrapper<>();
        enumWrapper.eq("app_id", appId);
        if (!StringUtils.isEmpty(dto.getEnumCode())) {
            enumWrapper.like("enum_code", dto.getEnumCode());
        }
        if (!StringUtils.isEmpty(dto.getEnumName())) {
            enumWrapper.like("enum_name", dto.getEnumName());
        }
        if (!StringUtils.isEmpty(dto.getValue())) {
            enumWrapper.eq("value", dto.getValue());
        }
        enumWrapper.orderByAsc("enum_code,sort_id");
        return ptEnumMapper.selectList(enumWrapper);
    }

    @Override
    public List<PtEnumDTO> getEnumByCode(PtEnumDTO dto) {
        QueryWrapper<PtEnum> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda().eq(PtEnum::getEnumCode, dto.getEnumCode());
        queryWrapper.lambda().eq(PtEnum::getAppId, dto.getAppId());
        List<PtEnum> ptEnums = ptEnumMapper.selectList(queryWrapper);
        return JSONArray.parseArray(JSONArray.toJSONString(ptEnums), PtEnumDTO.class);
    }

    @Override
    public void importEnum(MultipartFile file, String appId) {
        String fileContent = commService.parseExcelByTemplate("ENUM_IMPORT", file, "ptability-manage");
        JSONArray jsonArray = JSONArray.parseArray(fileContent);
        List<PtEnum> enumList = new ArrayList<>();
        for (Object o : jsonArray) {
            JSONObject jsonObject = JSONObject.parseObject(JSONObject.toJSONString(o));
            String sortId = jsonObject.get("sortId").toString();
            if (StringUtils.hasText(sortId)) {
                int sort = Double.valueOf(sortId).intValue();
                jsonObject.put("sortId", sort);
            }
            PtEnum ptEnum = JSONObject.parseObject(jsonObject.toJSONString(), PtEnum.class);
            enumList.add(ptEnum);
        }

        for (PtEnum ptEnum : enumList) {
            PtEnum ptEnum1 = ptEnumMapper.selectOne(new QueryWrapper<PtEnum>()
                    .eq("enum_code", ptEnum.getEnumCode())
                    .eq("app_id", appId)
                    .eq("value", ptEnum.getValue()));
            if (ptEnum1 != null) {
                ptEnum.setAppId(appId);
                ptEnumMapper.updatePtEnum(ptEnum);
            } else {
                ptEnum.setAppId(appId);
                ptEnumMapper.insertPtEnum(ptEnum);
            }
        }
    }


    /**
     * @title: download
     * @description:
     * @params:
     * @return: File
     * @createTime: 2022-4-18
     * @version: 1.0
     * @author: j26296
     */
    @Override
    public File download(PtEnumDTO paramsDTO, String templateCode, String fileName) {
        List<PtEnum> ptEnumList = queryEnumList(paramsDTO);
        return commService.generateExportFile(fileName, templateCode, "ptability-manage", (List) ptEnumList);
    }

    @Override
    public Map<String, List<PtEnum>> getAllEnumByAppId(PtEnumDTO dto) {
        String appId = dto.getAppId();
        if (StringUtils.isEmpty(appId)) {
            throw new BusinessException(20000, "appId不能为空");
        }
        QueryWrapper<PtEnum> queryWrapper = new QueryWrapper<>();
        queryWrapper.lambda()
                .eq(PtEnum::getAppId, appId).orderByAsc(PtEnum::getEnumCode, PtEnum::getSortId);
        List<PtEnum> ptEnums = ptEnumMapper.selectList(queryWrapper);
        Map<String, List<PtEnum>> enumListMap = ptEnums.stream().collect(Collectors.groupingBy(o -> o.getEnumCode()));
        return enumListMap;
    }

    @Override
    public File getExcelFile(ExcelFileDTO excelFileDTO) {
        return commService.generateExportFile(excelFileDTO.getFileName(), excelFileDTO.getTemplateCode(), excelFileDTO.getAppId(), excelFileDTO.getDataList());
    }

}
